{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "4040b4d2-3b7c-4773-aa76-5973306cf43a",
   "metadata": {},
   "source": [
    "# Python 函数详解\n",
    "\n",
    "函数是 Python 中组织代码、实现可重用性的基本单元。掌握函数的各项特性对于编写高效、模块化的代码至关重要。本讲义将详细介绍 Python 函数的多个方面，包括参数、返回值、不同传参方式、高阶函数和匿名函数等。\n",
    "\n",
    "---\n",
    "\n",
    "## 1. 函数基础\n",
    "\n",
    "### 1.1 什么是函数？\n",
    "\n",
    "- **定义**：函数是一段可重用的代码块，用于执行特定任务。函数可以接收输入（参数），处理后返回输出（返回值）。\n",
    "- **作用**：\n",
    "  - 提高代码复用性。\n",
    "  - 增强代码的可读性和维护性。\n",
    "  - 将复杂问题分解为更小的子任务。\n",
    "\n",
    "### 1.2 函数的定义\n",
    "\n",
    "- **语法**：\n",
    "\n",
    "  ```python\n",
    "  def 函数名(参数列表):\n",
    "      # 函数体\n",
    "      return 返回值\n",
    "  ```\n",
    "\n",
    "- **讲解**：\n",
    "\n",
    "  - `def` 关键字用于定义函数。\n",
    "  - `函数名` 遵循变量命名规则（小写字母加下划线，如 `my_function`）。\n",
    "  - `参数列表` 可选，定义函数接收的数据。\n",
    "  - `return` 语句用于返回结果（可选，若无 `return`，默认返回 `None`）。\n",
    "\n",
    "#### 示例"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "20e03675-af71-489d-9cce-5b634264fcf9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "你好, Alice!\n"
     ]
    }
   ],
   "source": [
    "# 定义一个简单的问候函数\n",
    "def greet(name):\n",
    "    return f\"你好, {name}!\"\n",
    "\n",
    "# 调用函数\n",
    "message = greet(\"Alice\")\n",
    "print(message)  # 输出: 你好, Alice!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "845176d7-ecaf-4195-af48-9a644c56391b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "我正在努力做计算\n",
      "7\n",
      "我已经计算完成了\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def add(a,b):\n",
    "    print(\"我正在努力做计算\")\n",
    "    c=a+b\n",
    "    print(c)\n",
    "    print(\"我已经计算完成了\")\n",
    "    return a+b\n",
    "add(5,2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "80dda94d-c204-494d-a1b3-314d7ba7d719",
   "metadata": {},
   "source": [
    "- **注释**：\n",
    "  - 函数 `greet` 接收一个参数 `name`，并返回一个格式化的问候语。\n",
    "  - `return` 语句将结果返回给调用者。\n",
    "\n",
    "### 1.3 函数的调用\n",
    "\n",
    "- **语法**：\n",
    "\n",
    "  ```python\n",
    "  函数名(参数)\n",
    "  ```\n",
    "\n",
    "- **讲解**：\n",
    "\n",
    "  - 调用时，传入的参数会传递给函数内部。\n",
    "  - 函数执行后，可以通过 `return` 获取返回值。\n",
    "\n",
    "#### 练习\n",
    "\n",
    "1. 定义一个函数 `add`，接收两个参数并返回它们的和。\n",
    "2. 定义一个函数 `is_even`，判断一个数是否为偶数，返回布尔值（如 `True` 或 `False`）。\n",
    "\n",
    "---\n",
    "\n",
    "## 2. 参数\n",
    "\n",
    "参数是函数接收的输入数据。Python 支持多种参数传递方式，灵活且强大。\n",
    "\n",
    "### 2.1 位置参数\n",
    "\n",
    "- **定义**：参数按定义时的顺序传递。\n",
    "- **讲解**：调用时参数的顺序和数量必须与定义时一致。\n",
    "\n",
    "#### 示例"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "995be710-e356-4af4-b892-02489e5563bc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "我有一只小白，它的名字是狗.\n"
     ]
    }
   ],
   "source": [
    "def describe_pet(animal, name):\n",
    "    print(f\"我有一只{animal}，它的名字是{name}.\")\n",
    "\n",
    "describe_pet(\"狗\", \"小白\")  # 输出: 我有一只狗，它的名字是小白."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4bc5c08-b0cf-4903-ba34-b5dccad66b28",
   "metadata": {},
   "source": [
    "- **注释**：\n",
    "  - `\"狗\"` 传递给 `animal`，`\"小白\"` 传递给 `name`，顺序必须匹配。\n",
    "\n",
    "### 2.2 关键字参数\n",
    "\n",
    "- **定义**：调用时通过参数名指定参数值。\n",
    "- **讲解**：可以不按定义顺序传递，提高代码可读性。\n",
    "\n",
    "#### 示例"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "35029384-ccad-4b67-8f7b-4dc8555cae76",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "我有一只猫，它的名字是小黑.\n"
     ]
    }
   ],
   "source": [
    "describe_pet(name=\"小黑\", animal=\"猫\")  # 输出: 我有一只猫，它的名字是小黑."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2d8c2f15-5da0-4015-90b5-805d27023ea1",
   "metadata": {},
   "source": [
    "- **注释**：\n",
    "  - 使用参数名赋值，不受位置限制。\n",
    "\n",
    "### 2.3 默认参数\n",
    "\n",
    "- **定义**：在定义时为参数指定默认值。\n",
    "- **讲解**：调用时如果不传入该参数，则使用默认值。\n",
    "\n",
    "#### 示例"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "02d7ba0f-708e-4a56-a9bb-75768b755d8b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "你好, 朋友!\n",
      "你好, Bob!\n"
     ]
    }
   ],
   "source": [
    "def greet(name=\"朋友\"):\n",
    "    return f\"你好, {name}!\"\n",
    "\n",
    "print(greet())       # 输出: 你好, 朋友!\n",
    "print(greet(\"Bob\"))  # 输出: 你好, Bob!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "540d12f2-1eb7-43f4-b7bf-a64ff6f0ff80",
   "metadata": {},
   "source": [
    "- 注释**：\n",
    "  - 未传入 `name` 时，使用默认值 `\"朋友\"`。\n",
    "  - 传入参数时，覆盖默认值。\n",
    "\n",
    "#### 注意事项\n",
    "\n",
    "- 默认参数必须放在非默认参数之后。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "1fefbdd7-019a-4763-8818-7d8294496d33",
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "parameter without a default follows parameter with a default (3864171683.py, line 3)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  Cell \u001b[0;32mIn[32], line 3\u001b[0;36m\u001b[0m\n\u001b[0;31m    def func(a=1, b):  # 错误，SyntaxError\u001b[0m\n\u001b[0m                  ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m parameter without a default follows parameter with a default\n"
     ]
    }
   ],
   "source": [
    "def func(a, b=1):  # 正确\n",
    "    pass\n",
    "def func(a=1, b):  # 错误，SyntaxError\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "292e4049-f5ce-4c19-b7f9-bc4695607e21",
   "metadata": {},
   "source": [
    "### 2.4 可变参数\n",
    "\n",
    "- **定义**：允许函数接收任意数量的参数。\n",
    "- **语法**：\n",
    "  - `*args`：接收任意数量的位置参数，存储为元组。\n",
    "  - `**kwargs`：接收任意数量的关键字参数，存储为字典。\n",
    "\n",
    "#### 示例 1：`*args`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "78fc52b8-39fd-4ae4-bcb0-17b21a5bcd3f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "def sum_all(*args):\n",
    "    return sum(args)\n",
    "\n",
    "print(sum_all(1, 2, 3,5))  # 输出: 6\n",
    "print(sum_all(4, 5))     # 输出: 9"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce74ece2-947f-4f93-933c-ba06eea384df",
   "metadata": {},
   "source": [
    "- 注释**：\n",
    "  - `*args` 接收多个参数，存储为元组，如 `(1, 2, 3)`。\n",
    "  - `sum()` 是内置函数，计算元组中所有元素的和。\n",
    "\n",
    "#### 示例 2：`**kwargs`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "87faf5b6-2a15-4ad6-a098-2b276625a5d8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "name: Alice\n",
      "age: 20\n"
     ]
    }
   ],
   "source": [
    "def print_info(**kwargs):\n",
    "    for key, value in kwargs.items():\n",
    "        print(f\"{key}: {value}\")\n",
    "\n",
    "print_info(name=\"Alice\", age=20)  # 输出: name: Alice\n",
    "                                  #       age: 20"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4b694130-0ceb-4a91-9918-5d73aea300da",
   "metadata": {},
   "source": [
    "- **注释**：\n",
    "  - `**kwargs` 接收键值对，存储为字典，如 `{\"name\": \"Alice\", \"age\": 20}`。\n",
    "  - 使用 `items()` 遍历字典的键值对。\n",
    "\n",
    "#### 练习\n",
    "\n",
    "1. 定义一个函数 `multiply_all`，接收任意数量的数字并返回它们的乘积。\n",
    "2. 定义一个函数 `display_info`，接收任意数量的关键字参数并打印它们的键值对。\n",
    "\n",
    "---\n",
    "\n",
    "## 3. 返回值\n",
    "\n",
    "- **作用**：函数通过 `return` 语句将结果返回给调用者。\n",
    "- **讲解**：\n",
    "  - 可以返回任意类型的值（如整数、字符串、列表、函数等）。\n",
    "  - 如果没有 `return`，函数默认返回 `None`。\n",
    "\n",
    "#### 示例"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "b03c1073-0993-49ac-8ca9-18b61b926d7a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16\n"
     ]
    }
   ],
   "source": [
    "def square(x):\n",
    "    return x * x\n",
    "\n",
    "result = square(4)\n",
    "print(result)  # 输出: 16"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d75a1fa-5b97-40e4-bdba-74823a6c12c6",
   "metadata": {},
   "source": [
    "- **注释**：\n",
    "  - `return x * x` 计算平方并返回结果。\n",
    "\n",
    "### 3.1 返回多个值\n",
    "\n",
    "- **讲解**：Python 允许通过元组返回多个值，调用时可以解包接收。\n",
    "- **示例**："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "a4fb23c7-c066-4088-8335-94410b17c92e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 4)\n",
      "1 4\n"
     ]
    }
   ],
   "source": [
    "def get_min_max(numbers):\n",
    "    return min(numbers), max(numbers)\n",
    "print(get_min_max([1, 2, 3, 4]))\n",
    "min_val, max_val = get_min_max([1, 2, 3, 4])\n",
    "print(min_val, max_val)  # 输出: 1 4"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "37b5f2b3-8bf0-4b2e-bf65-6da72e41ce5a",
   "metadata": {},
   "source": [
    "- **注释**：\n",
    "  - `return min(numbers), max(numbers)` 返回元组 `(1, 4)`。\n",
    "  - 调用时解包为 `min_val=1`，`max_val=4`。\n",
    "\n",
    "#### 练习\n",
    "\n",
    "1. 定义一个函数 `average`，接收一个列表并返回其平均值。\n",
    "2. 定义一个函数 `count_vowels`，接收一个字符串并返回其中元音字母（`a, e, i, o, u`）的数量。\n",
    "\n",
    "---\n",
    "\n",
    "## 4. 传参方式\n",
    "\n",
    "Python 中的参数传递是“传引用”，但具体行为取决于对象是否可变。\n",
    "\n",
    "### 4.1 不可变对象传参\n",
    "\n",
    "- **定义**：如整数、浮点数、字符串、元组。\n",
    "- **讲解**：传递的是对象的引用，但由于对象不可变，函数内修改不会影响原对象。\n",
    "\n",
    "#### 示例"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "904ebb39-4505-40bf-be64-17f650e60f68",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "def change_value(x):\n",
    "    x = 10  # 创建新对象，不影响外部\n",
    "    print(x)\n",
    "\n",
    "a = 5\n",
    "change_value(a)\n",
    "print(a)  # 输出: 5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "73845c04-40da-4772-a047-c077ed7762d6",
   "metadata": {},
   "source": [
    "- **注释**：\n",
    "  - `x = 10` 在函数内创建新对象，原变量 `a` 不变。\n",
    "\n",
    "### 4.2 可变对象传参\n",
    "\n",
    "- **定义**：如列表、字典、集合。\n",
    "- **讲解**：传递引用，函数内修改会影响原对象。\n",
    "\n",
    "#### 示例"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "ac815e02-7005-499e-9dff-dfcfb3ecd994",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "def change_list(lst):\n",
    "    lst.append(4)  # 修改原列表\n",
    "\n",
    "my_list = [1, 2, 3]\n",
    "change_list(my_list)\n",
    "print(my_list)  # 输出: [1, 2, 3, 4]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c2777da-6220-4549-84b6-80666ddb0209",
   "metadata": {},
   "source": [
    "- 注释**：\n",
    "  - `lst.append(4)` 直接修改传入的列表 `my_list`。\n",
    "\n",
    "#### 练习\n",
    "\n",
    "1. 定义一个函数 `add_element`，接收一个列表并在末尾添加一个元素。\n",
    "2. 定义一个函数 `update_dict`，接收一个字典并添加一个新键值对。\n",
    "\n",
    "---\n",
    "\n",
    "## 5. 数组传参（列表传参）\n",
    "\n",
    "- **讲解**：列表作为可变对象，传递时是引用，函数内修改会影响原列表。\n",
    "- **注意**：如果需要避免修改原列表，可以传入副本（如 `lst.copy()`）。\n",
    "\n",
    "#### 示例"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "ecd50a9c-6a81-4a83-a317-15eb98f0862a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['changed', 2, 3]\n"
     ]
    }
   ],
   "source": [
    "def modify_list(lst):\n",
    "    lst[0] = \"changed\"\n",
    "\n",
    "my_list = [1, 2, 3]\n",
    "modify_list(my_list)\n",
    "print(my_list)  # 输出: ['changed', 2, 3]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f098c96-d069-44a9-899f-66392e06454b",
   "metadata": {},
   "source": [
    "- **注释**：\n",
    "  - `lst[0] = \"changed\"` 直接修改原列表的第一个元素。\n",
    "\n",
    "#### 练习\n",
    "\n",
    "1. 定义一个函数 `double_list`，接收一个列表并将其所有元素乘以 2。\n",
    "\n",
    "---\n",
    "\n",
    "## 6. 字典传参\n",
    "\n",
    "- **讲解**：字典作为可变对象，传递时是引用，函数内修改会影响原字典。\n",
    "- **注意**：如果需要避免修改原字典，可以传入副本（如 `dict.copy()`）。\n",
    "\n",
    "#### 示例"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "050f2b09-1909-457f-b1c8-501902df545c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'key': 'value', 'new_key': 'new_value'}\n"
     ]
    }
   ],
   "source": [
    "def update_dict(d):\n",
    "    d[\"new_key\"] = \"new_value\"\n",
    "\n",
    "my_dict = {\"key\": \"value\"}\n",
    "update_dict(my_dict)\n",
    "print(my_dict)  # 输出: {'key': 'value', 'new_key': 'new_value'}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "657fa46b-46c4-4724-8d04-d72820df3dc0",
   "metadata": {},
   "source": [
    "- **注释**：\n",
    "  - `d[\"new_key\"] = \"new_value\"` 直接在原字典中添加新键值对。\n",
    "\n",
    "#### 练习\n",
    "\n",
    "1. 定义一个函数 `remove_key`，接收一个字典和一个键名，如果该键存在则删除它。\n",
    "\n",
    "---\n",
    "\n",
    "## 7. 高阶函数\n",
    "\n",
    "- **定义**：接收函数作为参数或返回函数的函数。\n",
    "- **作用**：实现函数的抽象和复用，增强代码灵活性。\n",
    "\n",
    "### 7.1 函数作为参数\n",
    "\n",
    "- **讲解**：可以将函数作为参数传递给其他函数，常用于回调或操作抽象。\n",
    "\n",
    "#### 示例"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "d042b498-41f1-4fb0-8ac3-0ad1e8e96f8b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16\n"
     ]
    }
   ],
   "source": [
    "def apply_func(func, value):\n",
    "    return func(value)\n",
    "\n",
    "def square(x):\n",
    "    return x * x\n",
    "\n",
    "result = apply_func(square, 4)\n",
    "print(result)  # 输出: 16"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6b1a503c-1535-4ae4-b213-a63b97953dd9",
   "metadata": {},
   "source": [
    "- **注释**：\n",
    "  - `apply_func` 接收函数 `square` 和值 `4`，并将 `square` 应用于 `4`。\n",
    "\n",
    "### 7.2 函数作为返回值\n",
    "\n",
    "- **讲解**：函数可以返回另一个函数，常用于生成定制化函数。\n",
    "\n",
    "#### 示例"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "c148f1b5-e119-46fc-8312-f459f2654739",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    }
   ],
   "source": [
    "def make_adder(n):\n",
    "    def adder(x):\n",
    "        return x + n\n",
    "    return adder\n",
    "\n",
    "add_5 = make_adder(5)\n",
    "print(add_5(3))  # 输出: 8"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03ffccaa-07d1-48f7-9d6f-92d40c696a22",
   "metadata": {},
   "source": [
    "- 注释**：\n",
    "  - `make_adder(5)` 返回一个函数 `adder`，该函数将输入值与 `5` 相加。\n",
    "\n",
    "#### 练习\n",
    "\n",
    "1. 编写一个高阶函数 `compose`，接收两个函数 `f` 和 `g`，返回一个新函数 `h(x) = f(g(x))`。\n",
    "2. 实现一个装饰器 `count_calls`，记录函数被调用的次数并打印。\n",
    "\n",
    "---\n",
    "\n",
    "## 8. 匿名函数（Lambda）\n",
    "\n",
    "- **定义**：使用 `lambda` 关键字定义的简短、无名函数。\n",
    "\n",
    "- **语法**：\n",
    "\n",
    "  ```python\n",
    "  lambda 参数: 表达式\n",
    "  ```\n",
    "\n",
    "- **讲解**：\n",
    "\n",
    "  - 适合定义一次性或简单函数。\n",
    "  - 常与高阶函数（如 `map`、`filter`、`sorted`）结合使用。\n",
    "\n",
    "#### 示例 1：基本使用"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "9bf08ac8-aa54-4a07-ba67-f5128958faca",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16\n"
     ]
    }
   ],
   "source": [
    "square = lambda x: x * x\n",
    "print(square(4))  # 输出: 16"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8fe2a712-c0fe-4b05-a52b-edb47b0aa9b0",
   "metadata": {},
   "source": [
    "示例 2：与 `map` 结合"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "e0a52984-c9a2-4904-9bf0-4faae5ffb760",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16]\n"
     ]
    }
   ],
   "source": [
    "numbers = [1, 2, 3, 4]\n",
    "squares = list(map(lambda x: x * x, numbers))\n",
    "print(squares)  # 输出: [1, 4, 9, 16]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f467385c-b51f-4e76-a3f7-f70b415590b0",
   "metadata": {},
   "source": [
    "- **注释**：\n",
    "  - `map` 将 `lambda x: x * x` 应用于 `numbers` 的每个元素。\n",
    "\n",
    "#### 示例 3：与 `sorted` 结合"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "204391c7-5404-412d-a58c-e5a6e2c9fe6d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(5, 0), (3, 1), (1, 2)]\n"
     ]
    }
   ],
   "source": [
    "points = [(1, 2), (3, 1), (5, 0)]\n",
    "sorted_points = sorted(points, key=lambda p: p[1])\n",
    "print(sorted_points)  # 输出: [(5, 0), (3, 1), (1, 2)]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07c6af43-f963-48ee-a7f7-cd608ba19e40",
   "metadata": {},
   "source": [
    "- **注释**：\n",
    "  - `key=lambda p: p[1]` 指定按元组的第二个元素（y 坐标）排序。\n",
    "\n",
    "#### 练习\n",
    "\n",
    "1. 使用 `lambda` 和 `filter` 筛选列表中的偶数。\n",
    "2. 使用 `lambda` 和 `sorted` 按字符串长度对列表排序。\n",
    "\n",
    "---\n",
    "\n",
    "## 9. 综合练习\n",
    "\n",
    "1. **计算器函数**：\n",
    "   - 定义一个函数 `calculator`，接收操作符（如 `\"+\"`、`\"-\"`、`\"*\"`、`\"/\"`）和两个数字，返回计算结果。\n",
    "\n",
    "2. **高阶函数应用**：\n",
    "   - 编写一个函数 `apply_operations`，接收一个列表和一个操作函数列表，应用每个操作函数到列表并返回结果列表。\n",
    "\n",
    "3. **匿名函数与高阶函数**：\n",
    "   - 使用 `lambda` 和 `reduce`（需从 `functools` 导入）计算列表中所有元素的乘积。\n",
    "\n",
    "---\n",
    "\n",
    "## 10. 总结\n",
    "\n",
    "- **参数**：\n",
    "  - 位置参数：按顺序传递。\n",
    "  - 关键字参数：按名称传递。\n",
    "  - 默认参数：提供默认值。\n",
    "  - 可变参数：`*args`（元组）、`**kwargs`（字典）。\n",
    "- **返回值**：\n",
    "  - 使用 `return` 返回任意类型，支持多值返回（元组）。\n",
    "- **传参方式**：\n",
    "  - 不可变对象：修改不影响原数据。\n",
    "  - 可变对象（如列表、字典）：修改影响原数据。\n",
    "- **数组传参**：列表作为可变对象，修改影响原列表。\n",
    "- **字典传参**：字典作为可变对象，修改影响原字典。\n",
    "- **高阶函数**：\n",
    "  - 函数可作为参数或返回值，实现抽象和复用。\n",
    "- **匿名函数**：\n",
    "  - `lambda` 提供简洁写法，常用于高阶函数。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f43f59a4-40d7-46fb-b2ea-dee9d4be7bec",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:base] *",
   "language": "python",
   "name": "conda-base-py"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
